import { deepClone } from '@/utils/clone';

// 判断是否为同正数或同负数
const isPositiveNumber = (num1, num2) => {
  if (num1 > 0 && num2 > 0) return true;
  if (num1 < 0 && num2 < 0) return true;
  return false;
};

// 获取数组的最大值和最小值
const getAllDataMaxNumAndMinNum = (data) => {
  const valueList = data.map((item) => item.value);
  const globalMaxNum = Math.max(...valueList);
  const globalMinNum = Math.min(...valueList);
  return { globalMaxNum, globalMinNum };
};

// 对比同组数据是否相近
const contrastGroupData = (groupData) => {
  const { globalMaxNum, globalMinNum } = getAllDataMaxNumAndMinNum(groupData.flat(1));
  const newList = deepClone(groupData);
  // 正数判断临界值函数
  const isBigGlobalMaxNum = (num1) => {
    return Math.abs(num1 - globalMaxNum) <= 40;
  };

  // 负数判断临界值函数
  const isSmallGlobalMinNum = (num1) => {
    return Math.abs(num1 - globalMinNum) <= 40;
  };

  // eslint-disable-next-line complexity
  newList.forEach((item) => {
    for (let i = 0; i < item.length; i++) {
      if (i === 0) continue;
      else {
        // 当前值是否大于上一个值函数 大于true 小于false
        const currentValueMoreThanPreValue = () => {
          return item[i].value > item[i - 1].value;
        };

        // 当前值与前一个值是同正数或同负数
        if (isPositiveNumber(item[i].value, item[i - 1].value)) {
          // 小于20
          if (Math.abs(item[i].value - item[i - 1].value) <= 20) {
            // 没调整过
            if (!item[i - 1].offset) {
              // 负数
              // eslint-disable-next-line max-depth
              if (item[i].value < 0) {
                // 超过临界值
                // eslint-disable-next-line max-depth
                if (isSmallGlobalMinNum(item[i].value)) {
                  // 是否大于上一个值
                  // eslint-disable-next-line max-depth
                  if (currentValueMoreThanPreValue()) {
                    item[i].offset = [0, -15];
                  }
                  // 小于上一个值
                  else {
                    item[i].offset = [0, 10];
                  }
                  continue;
                }

                // 不超过临界值
                // 是否大于上一个值
                // eslint-disable-next-line max-depth
                if (currentValueMoreThanPreValue()) {
                  item[i].offset = [0, -15];
                }
                // 小于上一个值
                else {
                  item[i].offset = [0, 12];
                }
              }
              // 正数
              else {
                // 超过临界值
                // eslint-disable-next-line max-depth
                if (isBigGlobalMaxNum(item[i].value)) {
                  // 是否大于上一个值
                  // eslint-disable-next-line max-depth
                  if (currentValueMoreThanPreValue()) {
                    item[i].offset = [0, 35];
                  }
                  // 小于上一个值
                  else {
                    item[i].offset = [0, 20];
                  }
                  continue;
                }

                // 没超过临界值
                // 是否大于上一个值
                // eslint-disable-next-line max-depth
                if (currentValueMoreThanPreValue()) {
                  item[i].offset = [0, -15];
                }
                // 小于上一个值
                else {
                  item[i].offset = [0, 20];
                }
                continue;
              }
            }
            // 调整过
            else {
              // 负数
              // eslint-disable-next-line max-depth
              if (item[i].value < 0) {
                // 超过临界值
                // eslint-disable-next-line max-depth
                if (isSmallGlobalMinNum(item[i].value)) {
                  // 当前值大于上一个值
                  // eslint-disable-next-line max-depth
                  if (currentValueMoreThanPreValue()) {
                    // 如果是等于0 往上移
                    // eslint-disable-next-line max-depth
                    if (item[i - 1].offset[1] === 0) {
                      item[i].offset = [0, -10];
                    }
                    // 如果是大于0证明下移
                    else if (item[i - 1].offset[1] > 0) {
                      item[i].offset = [0, -5];
                    }
                    // 如果是小于0证明上移
                    else {
                      item[i].offset = [0, 5];
                    }
                    continue;
                  }
                  // 当前值不大于上一个值
                  else {
                    // 如果是等于0 往上移
                    // eslint-disable-next-line max-depth
                    if (item[i - 1].offset[1] === 0) {
                      item[i].offset = [0, -25];
                    }
                    // 如果是大于0证明下移
                    else if (item[i - 1].offset[1] > 0) {
                      item[i].offset = [0, -20];
                    }
                    // 如果是小于0证明上移
                    else {
                      item[i].offset = [0, 0];
                    }
                    continue;
                  }
                }

                // 没超过临界值
                // 当前值大于上一个值
                if (currentValueMoreThanPreValue()) {
                  // eslint-disable-next-line max-depth
                  if (item[i - 1].offset[1] === 0) {
                    item[i].offset = [0, -10];
                  }
                  // 如果是大于0证明下移
                  else if (item[i - 1].offset[1] > 0) {
                    item[i].offset = [0, -10];
                  }
                  // 如果是小于0证明上移
                  else {
                    item[i].offset = [0, 15];
                  }
                }
                // 当前值小于上一个值
                else {
                  if (item[i - 1].offset[1] === 0) {
                    item[i].offset = [0, -20];
                  }
                  // 如果是大于0证明下移
                  else if (item[i - 1].offset[1] > 0) {
                    item[i].offset = [0, -10];
                  }
                  // 如果是小于0证明上移
                  else {
                    item[i].offset = [0, 0];
                  }
                }
              }
              // 正数
              else {
                // 超过临界值
                if (isBigGlobalMaxNum(item[i].value)) {
                  // 当前值大于上一个值
                  if (currentValueMoreThanPreValue()) {
                    // 等于0等于没移动 向下移
                    if (item[i - 1].offset[1] === 0) {
                      item[i].offset = [0, 20];
                    }
                    // 如果是大于0证明下移
                    else if (item[i - 1].offset[1] > 0) {
                      item[i].offset = [0, 10];
                    }
                    // 如果是小于0证明上移
                    else {
                      item[i].offset = [0, 20];
                    }
                  }
                  // 当前值小于上一个值
                  else {
                    // 等于0证明这个没动过，向下移
                    if (item[i - 1].offset[1] === 0) {
                      item[i].offset = [0, 15];
                    }
                    // 如果是大于0证明下移
                    else if (item[i - 1].offset[1] > 0) {
                      item[i].offset = [0, 0];
                    }
                    // 如果是小于0证明上移
                    else {
                      item[i].offset = [0, 0];
                    }
                  }
                  continue;
                }
                // 没超过临界值
                // 当前值大于上一个值
                if (currentValueMoreThanPreValue()) {
                  // 等于0证明这个没动过，向上移
                  if (item[i - 1].offset[1] === 0) {
                    item[i].offset = [0, -10];
                  }
                  // 如果是大于0证明下移
                  else if (item[i - 1].offset[1] > 0) {
                    item[i].offset = [0, 0];
                  }
                  // 如果是小于0证明上移
                  else {
                    item[i].offset = [0, 14];
                  }
                } else {
                  // 等于0证明这个没动过，向下移
                  if (item[i - 1].offset[1] === 0) {
                    item[i].offset = [0, 12];
                  }
                  // 如果是大于0证明上移
                  else if (item[i - 1].offset[1] > 0) {
                    item[i].offset = [0, -5];
                  }
                  // 如果是小于0证明上移 归为0
                  else {
                    item[i].offset = [0, 0];
                  }
                }
              }
            }
          }
        }
      }
    }
  });
  return newList;
};

// 获取负数的最大偏移值
const getMinNumOffsetX = (data) => {
  const newData = [];
  data.forEach((item) => {
    if (item.value < 0 && item.offset) {
      newData.push(item.offset[1]);
    }
  });
  return Math.max(...newData);
};

// 源数据转向组数据
const seriesDataToGroupData = (data) => {
  const arr = [];
  for (let i = 0; i < data[0]?.length; i++) {
    let list = [];
    for (let j = 0; j < data.length; j++) {
      if (data[j][i].label.show) list.push({ id: j, value: data[j][i].value });
    }
    arr.push(list);
    list = null;
  }
  return arr;
};

// 组数据转换源数据
const groupDataToSeriesData = (arr, resultArr) => {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      const index = arr[i][j].id;
      if (arr[i][j].offset) resultArr[index][i].label.offset = arr[i][j].offset;
    }
  }
};

export { contrastGroupData, seriesDataToGroupData, groupDataToSeriesData, getMinNumOffsetX };
